home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 April: Mac OS SDK / Dev.CD Apr 99 SDK1.toast / Development Kits / Interfaces&Libraries / Universal / Interfaces / PInterfaces / Quickdraw.p < prev    next >
Encoding:
Text File  |  1998-08-17  |  67.8 KB  |  2,086 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Quickdraw.p
  3.  
  4.      Contains:    Interface to Quickdraw Graphics
  5.  
  6.      Version:    Technology:    Mac OS 8.1
  7.                  Release:    Universal Interfaces 3.2
  8.  
  9.      Copyright:    © 1985-1998 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. }
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT Quickdraw;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __QUICKDRAW__}
  27. {$SETC __QUICKDRAW__ := 1}
  28.  
  29. {$I+}
  30. {$SETC QuickdrawIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33. {$IFC UNDEFINED __MACTYPES__}
  34. {$I MacTypes.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED __MIXEDMODE__}
  37. {$I MixedMode.p}
  38. {$ENDC}
  39. {$IFC UNDEFINED __QUICKDRAWTEXT__}
  40. {$I QuickdrawText.p}
  41. {$ENDC}
  42.  
  43.  
  44. {$PUSH}
  45. {$ALIGN MAC68K}
  46. {$LibExport+}
  47.  
  48.  
  49. CONST
  50.     invalColReq                    = -1;                            { invalid color table request }
  51.  
  52.                                                                 {  transfer modes  }
  53.     srcCopy                        = 0;                            { the 16 transfer modes }
  54.     srcOr                        = 1;
  55.     srcXor                        = 2;
  56.     srcBic                        = 3;
  57.     notSrcCopy                    = 4;
  58.     notSrcOr                    = 5;
  59.     notSrcXor                    = 6;
  60.     notSrcBic                    = 7;
  61.     patCopy                        = 8;
  62.     patOr                        = 9;
  63.     patXor                        = 10;
  64.     patBic                        = 11;
  65.     notPatCopy                    = 12;
  66.     notPatOr                    = 13;
  67.     notPatXor                    = 14;
  68.     notPatBic                    = 15;                            {  Special Text Transfer Mode  }
  69.     grayishTextOr                = 49;
  70.     hilitetransfermode            = 50;
  71.     hilite                        = 50;                            {  Arithmetic transfer modes  }
  72.     blend                        = 32;
  73.     addPin                        = 33;
  74.     addOver                        = 34;
  75.     subPin                        = 35;
  76.     addMax                        = 37;
  77.     adMax                        = 37;
  78.     subOver                        = 38;
  79.     adMin                        = 39;
  80.     ditherCopy                    = 64;                            {  Transparent mode constant  }
  81.     transparent                    = 36;
  82.  
  83.     italicBit                    = 1;
  84.     ulineBit                    = 2;
  85.     outlineBit                    = 3;
  86.     shadowBit                    = 4;
  87.     condenseBit                    = 5;
  88.     extendBit                    = 6;
  89.  
  90.                                                                 {  QuickDraw color separation constants  }
  91.     normalBit                    = 0;                            { normal screen mapping }
  92.     inverseBit                    = 1;                            { inverse screen mapping }
  93.     redBit                        = 4;                            { RGB additive mapping }
  94.     greenBit                    = 3;
  95.     blueBit                        = 2;
  96.     cyanBit                        = 8;                            { CMYBk subtractive mapping }
  97.     magentaBit                    = 7;
  98.     yellowBit                    = 6;
  99.     blackBit                    = 5;
  100.  
  101.     blackColor                    = 33;                            { colors expressed in these mappings }
  102.     whiteColor                    = 30;
  103.     redColor                    = 205;
  104.     greenColor                    = 341;
  105.     blueColor                    = 409;
  106.     cyanColor                    = 273;
  107.     magentaColor                = 137;
  108.     yellowColor                    = 69;
  109.  
  110.     picLParen                    = 0;                            { standard picture comments }
  111.     picRParen                    = 1;
  112.     clutType                    = 0;                            { 0 if lookup table }
  113.     fixedType                    = 1;                            { 1 if fixed table }
  114.     directType                    = 2;                            { 2 if direct values }
  115.     gdDevType                    = 0;                            { 0 = monochrome 1 = color }
  116.  
  117.     interlacedDevice            = 2;                            {  1 if single pixel lines look bad  }
  118.     roundedDevice                = 5;                            {  1 if device has been “rounded” into the GrayRgn  }
  119.     hasAuxMenuBar                = 6;                            {  1 if device has an aux menu bar on it  }
  120.     burstDevice                    = 7;
  121.     ext32Device                    = 8;
  122.     ramInit                        = 10;                            { 1 if initialized from 'scrn' resource }
  123.     mainScreen                    = 11;                            {  1 if main screen  }
  124.     allInit                        = 12;                            {  1 if all devices initialized  }
  125.     screenDevice                = 13;                            { 1 if screen device [not used] }
  126.     noDriver                    = 14;                            {  1 if no driver for this GDevice  }
  127.     screenActive                = 15;                            { 1 if in use }
  128.     hiliteBit                    = 7;                            { flag bit in HiliteMode (lowMem flag) }
  129.     pHiliteBit                    = 0;                            { flag bit in HiliteMode used with BitClr procedure }
  130.     defQDColors                    = 127;                            { resource ID of clut for default QDColors }
  131.                                                                 {  pixel type  }
  132.     RGBDirect                    = 16;                            {  16 & 32 bits/pixel pixelType value  }
  133.                                                                 {  pmVersion values  }
  134.     baseAddr32                    = 4;                            { pixmap base address is 32-bit address }
  135.  
  136.  
  137.     sysPatListID                = 0;
  138.     iBeamCursor                    = 1;
  139.     crossCursor                    = 2;
  140.     plusCursor                    = 3;
  141.     watchCursor                    = 4;
  142.  
  143.     kQDGrafVerbFrame            = 0;
  144.     kQDGrafVerbPaint            = 1;
  145.     kQDGrafVerbErase            = 2;
  146.     kQDGrafVerbInvert            = 3;
  147.     kQDGrafVerbFill                = 4;
  148.  
  149. {$IFC OLDROUTINENAMES }
  150.     frame                        = 0;
  151.     paint                        = 1;
  152.     erase                        = 2;
  153.     invert                        = 3;
  154.     fill                        = 4;
  155.  
  156. {$ENDC}  {OLDROUTINENAMES}
  157.  
  158.  
  159. TYPE
  160.     GrafVerb                            = SInt8;
  161.  
  162. CONST
  163.     chunky                        = 0;
  164.     chunkyPlanar                = 1;
  165.     planar                        = 2;
  166.  
  167.  
  168. TYPE
  169.     PixelType                            = SInt8;
  170.     Bits16                                = ARRAY [0..15] OF INTEGER;
  171.  
  172. {**************   IMPORTANT NOTE REGARDING Pattern  **************************************
  173.    Patterns were originally defined as:
  174.    
  175.         C:             typedef unsigned char Pattern[8];
  176.         Pascal:        Pattern = PACKED ARRAY [0..7] OF 0..255;
  177.         
  178.    The old array definition of Pattern would cause 68000 based CPU's to crash in certain circum-
  179.    stances. The new struct definition is safe, but may require source code changes to compile.
  180.     
  181. ********************************************************************************************}
  182.     PatternPtr = ^Pattern;
  183.     Pattern = RECORD
  184.         pat:                    PACKED ARRAY [0..7] OF UInt8;
  185.     END;
  186.  
  187. {
  188.  ConstPatternParam is no longer needed.  It was first created when Pattern was an array.
  189.  Now that Pattern is a struct, it is more straight forward to just add the "const" qualifier
  190.  on the parameter type (e.g. "const Pattern * pat" instead of "ConstPatternParam pat").
  191. }
  192.     PatPtr                                = ^Pattern;
  193.     PatHandle                            = ^PatPtr;
  194.     QDByte                                = SignedByte;
  195.     QDPtr                                = Ptr;
  196.     QDHandle                            = Handle;
  197.     QDErr                                = INTEGER;
  198.  
  199. CONST
  200.     singleDevicesBit            = 0;
  201.     dontMatchSeedsBit            = 1;
  202.     allDevicesBit                = 2;
  203.  
  204.     singleDevices                = $01;
  205.     dontMatchSeeds                = $02;
  206.     allDevices                    = $04;
  207.  
  208.  
  209. TYPE
  210.     DeviceLoopFlags                        = UInt32;
  211. {
  212.     PrinterStatusOpcode.  For communication with downloading and printing services.
  213. }
  214.     PrinterStatusOpcode                    = SInt32;
  215.  
  216. CONST
  217.     kPrinterFontStatus            = 0;
  218.     kPrinterScalingStatus        = 1;
  219.  
  220.  
  221. TYPE
  222.     PrinterFontStatusPtr = ^PrinterFontStatus;
  223.     PrinterFontStatus = RECORD
  224.         oResult:                SInt32;
  225.         iFondID:                SInt16;
  226.         iStyle:                    SInt8;
  227.     END;
  228.  
  229.     PrinterScalingStatusPtr = ^PrinterScalingStatus;
  230.     PrinterScalingStatus = RECORD
  231.         oScalingFactors:        Point;
  232.     END;
  233.  
  234.     BitMapPtr = ^BitMap;
  235.     BitMap = RECORD
  236.         baseAddr:                Ptr;
  237.         rowBytes:                INTEGER;
  238.         bounds:                    Rect;
  239.     END;
  240.  
  241.     BitMapHandle                        = ^BitMapPtr;
  242.     CursorPtr = ^Cursor;
  243.     Cursor = RECORD
  244.         data:                    Bits16;
  245.         mask:                    Bits16;
  246.         hotSpot:                Point;
  247.     END;
  248.  
  249.     CursPtr                                = ^Cursor;
  250.     CursHandle                            = ^CursPtr;
  251.     PenStatePtr = ^PenState;
  252.     PenState = RECORD
  253.         pnLoc:                    Point;
  254.         pnSize:                    Point;
  255.         pnMode:                    INTEGER;
  256.         pnPat:                    Pattern;
  257.     END;
  258.  
  259.     MacRegionPtr = ^MacRegion;
  260.     MacRegion = RECORD
  261.         rgnSize:                UInt16;                                    { size in bytes }
  262.         rgnBBox:                Rect;                                    { enclosing rectangle }
  263.     END;
  264.  
  265. {
  266.     The type name "Region" has a name space collision on Win32.
  267.     Use MacRegion to be cross-platfrom safe.
  268. }
  269. {$IFC TARGET_OS_MAC }
  270.     Region                                = MacRegion;
  271.     RegionPtr                             = ^Region;
  272. {$ENDC}  {TARGET_OS_MAC}
  273.  
  274.     RgnPtr                                = ^MacRegion;
  275.     RgnHandle                            = ^RgnPtr;
  276.     PicturePtr = ^Picture;
  277.     Picture = RECORD
  278.         picSize:                INTEGER;
  279.         picFrame:                Rect;
  280.     END;
  281.  
  282.     PicPtr                                = ^Picture;
  283.     PicHandle                            = ^PicPtr;
  284.     MacPolygonPtr = ^MacPolygon;
  285.     MacPolygon = RECORD
  286.         polySize:                INTEGER;
  287.         polyBBox:                Rect;
  288.         polyPoints:                ARRAY [0..0] OF Point;
  289.     END;
  290.  
  291. {
  292.     The type name "Polygon" has a name space collision on Win32.
  293.     Use MacPolygon to be cross-platfrom safe.
  294. }
  295. {$IFC TARGET_OS_MAC }
  296.     Polygon                                = MacPolygon;
  297.     PolygonPtr                             = ^Polygon;
  298. {$ENDC}  {TARGET_OS_MAC}
  299.  
  300.     PolyPtr                                = ^MacPolygon;
  301.     PolyHandle                            = ^PolyPtr;
  302. {$IFC TYPED_FUNCTION_POINTERS}
  303.     QDTextProcPtr = PROCEDURE(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point);
  304. {$ELSEC}
  305.     QDTextProcPtr = ProcPtr;
  306. {$ENDC}
  307.  
  308. {$IFC TYPED_FUNCTION_POINTERS}
  309.     QDLineProcPtr = PROCEDURE(newPt: Point);
  310. {$ELSEC}
  311.     QDLineProcPtr = ProcPtr;
  312. {$ENDC}
  313.  
  314. {$IFC TYPED_FUNCTION_POINTERS}
  315.     QDRectProcPtr = PROCEDURE(verb: GrafVerb; VAR r: Rect);
  316. {$ELSEC}
  317.     QDRectProcPtr = ProcPtr;
  318. {$ENDC}
  319.  
  320. {$IFC TYPED_FUNCTION_POINTERS}
  321.     QDRRectProcPtr = PROCEDURE(verb: GrafVerb; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  322. {$ELSEC}
  323.     QDRRectProcPtr = ProcPtr;
  324. {$ENDC}
  325.  
  326. {$IFC TYPED_FUNCTION_POINTERS}
  327.     QDOvalProcPtr = PROCEDURE(verb: GrafVerb; VAR r: Rect);
  328. {$ELSEC}
  329.     QDOvalProcPtr = ProcPtr;
  330. {$ENDC}
  331.  
  332. {$IFC TYPED_FUNCTION_POINTERS}
  333.     QDArcProcPtr = PROCEDURE(verb: GrafVerb; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  334. {$ELSEC}
  335.     QDArcProcPtr = ProcPtr;
  336. {$ENDC}
  337.  
  338. {$IFC TYPED_FUNCTION_POINTERS}
  339.     QDPolyProcPtr = PROCEDURE(verb: GrafVerb; poly: PolyHandle);
  340. {$ELSEC}
  341.     QDPolyProcPtr = ProcPtr;
  342. {$ENDC}
  343.  
  344. {$IFC TYPED_FUNCTION_POINTERS}
  345.     QDRgnProcPtr = PROCEDURE(verb: GrafVerb; rgn: RgnHandle);
  346. {$ELSEC}
  347.     QDRgnProcPtr = ProcPtr;
  348. {$ENDC}
  349.  
  350. {$IFC TYPED_FUNCTION_POINTERS}
  351.     QDBitsProcPtr = PROCEDURE(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  352. {$ELSEC}
  353.     QDBitsProcPtr = ProcPtr;
  354. {$ENDC}
  355.  
  356. {$IFC TYPED_FUNCTION_POINTERS}
  357.     QDCommentProcPtr = PROCEDURE(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  358. {$ELSEC}
  359.     QDCommentProcPtr = ProcPtr;
  360. {$ENDC}
  361.  
  362. {$IFC TYPED_FUNCTION_POINTERS}
  363.     QDTxMeasProcPtr = FUNCTION(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo): INTEGER;
  364. {$ELSEC}
  365.     QDTxMeasProcPtr = ProcPtr;
  366. {$ENDC}
  367.  
  368. {$IFC TYPED_FUNCTION_POINTERS}
  369.     QDGetPicProcPtr = PROCEDURE(dataPtr: Ptr; byteCount: INTEGER);
  370. {$ELSEC}
  371.     QDGetPicProcPtr = ProcPtr;
  372. {$ENDC}
  373.  
  374. {$IFC TYPED_FUNCTION_POINTERS}
  375.     QDPutPicProcPtr = PROCEDURE(dataPtr: Ptr; byteCount: INTEGER);
  376. {$ELSEC}
  377.     QDPutPicProcPtr = ProcPtr;
  378. {$ENDC}
  379.  
  380. {$IFC TYPED_FUNCTION_POINTERS}
  381.     QDOpcodeProcPtr = PROCEDURE(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER);
  382. {$ELSEC}
  383.     QDOpcodeProcPtr = ProcPtr;
  384. {$ENDC}
  385.  
  386. {$IFC TYPED_FUNCTION_POINTERS}
  387.     QDStdGlyphsProcPtr = FUNCTION(dataStream: UNIV Ptr; size: ByteCount): OSStatus; C;
  388. {$ELSEC}
  389.     QDStdGlyphsProcPtr = ProcPtr;
  390. {$ENDC}
  391.  
  392. {$IFC TYPED_FUNCTION_POINTERS}
  393.     QDJShieldCursorProcPtr = PROCEDURE(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  394. {$ELSEC}
  395.     QDJShieldCursorProcPtr = ProcPtr;
  396. {$ENDC}
  397.  
  398.     QDTextUPP = UniversalProcPtr;
  399.     QDLineUPP = UniversalProcPtr;
  400.     QDRectUPP = UniversalProcPtr;
  401.     QDRRectUPP = UniversalProcPtr;
  402.     QDOvalUPP = UniversalProcPtr;
  403.     QDArcUPP = UniversalProcPtr;
  404.     QDPolyUPP = UniversalProcPtr;
  405.     QDRgnUPP = UniversalProcPtr;
  406.     QDBitsUPP = UniversalProcPtr;
  407.     QDCommentUPP = UniversalProcPtr;
  408.     QDTxMeasUPP = UniversalProcPtr;
  409.     QDGetPicUPP = UniversalProcPtr;
  410.     QDPutPicUPP = UniversalProcPtr;
  411.     QDOpcodeUPP = UniversalProcPtr;
  412.     QDStdGlyphsUPP = UniversalProcPtr;
  413.     QDJShieldCursorUPP = UniversalProcPtr;
  414.     QDProcsPtr = ^QDProcs;
  415.     QDProcs = RECORD
  416.         textProc:                QDTextUPP;
  417.         lineProc:                QDLineUPP;
  418.         rectProc:                QDRectUPP;
  419.         rRectProc:                QDRRectUPP;
  420.         ovalProc:                QDOvalUPP;
  421.         arcProc:                QDArcUPP;
  422.         polyProc:                QDPolyUPP;
  423.         rgnProc:                QDRgnUPP;
  424.         bitsProc:                QDBitsUPP;
  425.         commentProc:            QDCommentUPP;
  426.         txMeasProc:                QDTxMeasUPP;
  427.         getPicProc:                QDGetPicUPP;
  428.         putPicProc:                QDPutPicUPP;
  429.     END;
  430.  
  431.  
  432. CONST
  433.     uppQDTextProcInfo = $00003F80;
  434.     uppQDLineProcInfo = $000000C0;
  435.     uppQDRectProcInfo = $00000340;
  436.     uppQDRRectProcInfo = $00002B40;
  437.     uppQDOvalProcInfo = $00000340;
  438.     uppQDArcProcInfo = $00002B40;
  439.     uppQDPolyProcInfo = $00000340;
  440.     uppQDRgnProcInfo = $00000340;
  441.     uppQDBitsProcInfo = $0000EFC0;
  442.     uppQDCommentProcInfo = $00000E80;
  443.     uppQDTxMeasProcInfo = $0000FFA0;
  444.     uppQDGetPicProcInfo = $000002C0;
  445.     uppQDPutPicProcInfo = $000002C0;
  446.     uppQDOpcodeProcInfo = $00002BC0;
  447.     uppQDStdGlyphsProcInfo = $000003F1;
  448.     uppQDJShieldCursorProcInfo = $00002A80;
  449.  
  450. FUNCTION NewQDTextProc(userRoutine: QDTextProcPtr): QDTextUPP;
  451.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  452.     INLINE $2E9F;
  453.     {$ENDC}
  454.  
  455. FUNCTION NewQDLineProc(userRoutine: QDLineProcPtr): QDLineUPP;
  456.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  457.     INLINE $2E9F;
  458.     {$ENDC}
  459.  
  460. FUNCTION NewQDRectProc(userRoutine: QDRectProcPtr): QDRectUPP;
  461.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  462.     INLINE $2E9F;
  463.     {$ENDC}
  464.  
  465. FUNCTION NewQDRRectProc(userRoutine: QDRRectProcPtr): QDRRectUPP;
  466.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  467.     INLINE $2E9F;
  468.     {$ENDC}
  469.  
  470. FUNCTION NewQDOvalProc(userRoutine: QDOvalProcPtr): QDOvalUPP;
  471.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  472.     INLINE $2E9F;
  473.     {$ENDC}
  474.  
  475. FUNCTION NewQDArcProc(userRoutine: QDArcProcPtr): QDArcUPP;
  476.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  477.     INLINE $2E9F;
  478.     {$ENDC}
  479.  
  480. FUNCTION NewQDPolyProc(userRoutine: QDPolyProcPtr): QDPolyUPP;
  481.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  482.     INLINE $2E9F;
  483.     {$ENDC}
  484.  
  485. FUNCTION NewQDRgnProc(userRoutine: QDRgnProcPtr): QDRgnUPP;
  486.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  487.     INLINE $2E9F;
  488.     {$ENDC}
  489.  
  490. FUNCTION NewQDBitsProc(userRoutine: QDBitsProcPtr): QDBitsUPP;
  491.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  492.     INLINE $2E9F;
  493.     {$ENDC}
  494.  
  495. FUNCTION NewQDCommentProc(userRoutine: QDCommentProcPtr): QDCommentUPP;
  496.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  497.     INLINE $2E9F;
  498.     {$ENDC}
  499.  
  500. FUNCTION NewQDTxMeasProc(userRoutine: QDTxMeasProcPtr): QDTxMeasUPP;
  501.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  502.     INLINE $2E9F;
  503.     {$ENDC}
  504.  
  505. FUNCTION NewQDGetPicProc(userRoutine: QDGetPicProcPtr): QDGetPicUPP;
  506.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  507.     INLINE $2E9F;
  508.     {$ENDC}
  509.  
  510. FUNCTION NewQDPutPicProc(userRoutine: QDPutPicProcPtr): QDPutPicUPP;
  511.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  512.     INLINE $2E9F;
  513.     {$ENDC}
  514.  
  515. FUNCTION NewQDOpcodeProc(userRoutine: QDOpcodeProcPtr): QDOpcodeUPP;
  516.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  517.     INLINE $2E9F;
  518.     {$ENDC}
  519.  
  520. FUNCTION NewQDStdGlyphsProc(userRoutine: QDStdGlyphsProcPtr): QDStdGlyphsUPP;
  521.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  522.     INLINE $2E9F;
  523.     {$ENDC}
  524.  
  525. FUNCTION NewQDJShieldCursorProc(userRoutine: QDJShieldCursorProcPtr): QDJShieldCursorUPP;
  526.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  527.     INLINE $2E9F;
  528.     {$ENDC}
  529.  
  530. PROCEDURE CallQDTextProc(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point; userRoutine: QDTextUPP);
  531.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  532.     INLINE $205F, $4E90;
  533.     {$ENDC}
  534.  
  535. PROCEDURE CallQDLineProc(newPt: Point; userRoutine: QDLineUPP);
  536.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  537.     INLINE $205F, $4E90;
  538.     {$ENDC}
  539.  
  540. PROCEDURE CallQDRectProc(verb: GrafVerb; VAR r: Rect; userRoutine: QDRectUPP);
  541.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  542.     INLINE $205F, $4E90;
  543.     {$ENDC}
  544.  
  545. PROCEDURE CallQDRRectProc(verb: GrafVerb; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; userRoutine: QDRRectUPP);
  546.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  547.     INLINE $205F, $4E90;
  548.     {$ENDC}
  549.  
  550. PROCEDURE CallQDOvalProc(verb: GrafVerb; VAR r: Rect; userRoutine: QDOvalUPP);
  551.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  552.     INLINE $205F, $4E90;
  553.     {$ENDC}
  554.  
  555. PROCEDURE CallQDArcProc(verb: GrafVerb; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; userRoutine: QDArcUPP);
  556.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  557.     INLINE $205F, $4E90;
  558.     {$ENDC}
  559.  
  560. PROCEDURE CallQDPolyProc(verb: GrafVerb; poly: PolyHandle; userRoutine: QDPolyUPP);
  561.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  562.     INLINE $205F, $4E90;
  563.     {$ENDC}
  564.  
  565. PROCEDURE CallQDRgnProc(verb: GrafVerb; rgn: RgnHandle; userRoutine: QDRgnUPP);
  566.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  567.     INLINE $205F, $4E90;
  568.     {$ENDC}
  569.  
  570. PROCEDURE CallQDBitsProc(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle; userRoutine: QDBitsUPP);
  571.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  572.     INLINE $205F, $4E90;
  573.     {$ENDC}
  574.  
  575. PROCEDURE CallQDCommentProc(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle; userRoutine: QDCommentUPP);
  576.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  577.     INLINE $205F, $4E90;
  578.     {$ENDC}
  579.  
  580. FUNCTION CallQDTxMeasProc(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo; userRoutine: QDTxMeasUPP): INTEGER;
  581.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  582.     INLINE $205F, $4E90;
  583.     {$ENDC}
  584.  
  585. PROCEDURE CallQDGetPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDGetPicUPP);
  586.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  587.     INLINE $205F, $4E90;
  588.     {$ENDC}
  589.  
  590. PROCEDURE CallQDPutPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDPutPicUPP);
  591.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  592.     INLINE $205F, $4E90;
  593.     {$ENDC}
  594.  
  595. PROCEDURE CallQDOpcodeProc(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER; userRoutine: QDOpcodeUPP);
  596.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  597.     INLINE $205F, $4E90;
  598.     {$ENDC}
  599.  
  600. FUNCTION CallQDStdGlyphsProc(dataStream: UNIV Ptr; size: ByteCount; userRoutine: QDStdGlyphsUPP): OSStatus;
  601.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  602.     {To be implemented:  Glue to move parameters into registers.}
  603.     {$ENDC}
  604.  
  605. PROCEDURE CallQDJShieldCursorProc(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER; userRoutine: QDJShieldCursorUPP);
  606.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  607.     INLINE $205F, $4E90;
  608.     {$ENDC}
  609.  
  610. TYPE
  611.     GrafPortPtr = ^GrafPort;
  612.     GrafPort = RECORD
  613.         device:                    INTEGER;
  614.         portBits:                BitMap;
  615.         portRect:                Rect;
  616.         visRgn:                    RgnHandle;
  617.         clipRgn:                RgnHandle;
  618.         bkPat:                    Pattern;
  619.         fillPat:                Pattern;
  620.         pnLoc:                    Point;
  621.         pnSize:                    Point;
  622.         pnMode:                    INTEGER;
  623.         pnPat:                    Pattern;
  624.         pnVis:                    INTEGER;
  625.         txFont:                    INTEGER;
  626.         txFace:                    StyleField;                                { StyleField occupies 16-bits, but only first 8-bits are used }
  627.         txMode:                    INTEGER;
  628.         txSize:                    INTEGER;
  629.         spExtra:                Fixed;
  630.         fgColor:                LONGINT;
  631.         bkColor:                LONGINT;
  632.         colrBit:                INTEGER;
  633.         patStretch:                INTEGER;
  634.         picSave:                Handle;
  635.         rgnSave:                Handle;
  636.         polySave:                Handle;
  637.         grafProcs:                QDProcsPtr;
  638.     END;
  639.  
  640.     GrafPtr                                = ^GrafPort;
  641.  
  642. {
  643.  *    This set of definitions "belongs" in Windows.
  644.  *    But, there is a circularity in the headers where Windows includes Controls and
  645.  *    Controls includes Windows. To break the circle, the information
  646.  *    needed by Controls is moved from Windows to Quickdraw.
  647.  }
  648.     WindowPtr                            = GrafPtr;
  649.     DialogPtr                            = WindowPtr;
  650.     WindowRef                            = WindowPtr;
  651. {  DragConstraint constants to pass to DragGray,DragTheRgn, or ConstrainedDragRgn }
  652.     DragConstraint                        = UInt16;
  653.  
  654. CONST
  655.     kNoConstraint                = 0;
  656.     kVerticalConstraint            = 1;
  657.     kHorizontalConstraint        = 2;
  658.  
  659.  
  660.  
  661. TYPE
  662. {$IFC TYPED_FUNCTION_POINTERS}
  663.     DragGrayRgnProcPtr = PROCEDURE;
  664. {$ELSEC}
  665.     DragGrayRgnProcPtr = ProcPtr;
  666. {$ENDC}
  667.  
  668. {
  669.  *    Here ends the list of things that "belong" in Windows.
  670.  }
  671.  
  672.  
  673.     RGBColorPtr = ^RGBColor;
  674.     RGBColor = RECORD
  675.         red:                    UInt16;                                    { magnitude of red component }
  676.         green:                    UInt16;                                    { magnitude of green component }
  677.         blue:                    UInt16;                                    { magnitude of blue component }
  678.     END;
  679.  
  680.     RGBColorHdl                            = ^RGBColorPtr;
  681. {$IFC TYPED_FUNCTION_POINTERS}
  682.     ColorSearchProcPtr = FUNCTION(VAR rgb: RGBColor; VAR position: LONGINT): BOOLEAN;
  683. {$ELSEC}
  684.     ColorSearchProcPtr = ProcPtr;
  685. {$ENDC}
  686.  
  687. {$IFC TYPED_FUNCTION_POINTERS}
  688.     ColorComplementProcPtr = FUNCTION(VAR rgb: RGBColor): BOOLEAN;
  689. {$ELSEC}
  690.     ColorComplementProcPtr = ProcPtr;
  691. {$ENDC}
  692.  
  693.     DragGrayRgnUPP = UniversalProcPtr;
  694.     ColorSearchUPP = UniversalProcPtr;
  695.     ColorComplementUPP = UniversalProcPtr;
  696.  
  697. CONST
  698.     uppDragGrayRgnProcInfo = $00000000;
  699.     uppColorSearchProcInfo = $000003D0;
  700.     uppColorComplementProcInfo = $000000D0;
  701.  
  702. FUNCTION NewDragGrayRgnProc(userRoutine: DragGrayRgnProcPtr): DragGrayRgnUPP;
  703.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  704.     INLINE $2E9F;
  705.     {$ENDC}
  706.  
  707. FUNCTION NewColorSearchProc(userRoutine: ColorSearchProcPtr): ColorSearchUPP;
  708.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  709.     INLINE $2E9F;
  710.     {$ENDC}
  711.  
  712. FUNCTION NewColorComplementProc(userRoutine: ColorComplementProcPtr): ColorComplementUPP;
  713.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  714.     INLINE $2E9F;
  715.     {$ENDC}
  716.  
  717. PROCEDURE CallDragGrayRgnProc(userRoutine: DragGrayRgnUPP);
  718.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  719.     INLINE $205F, $4E90;
  720.     {$ENDC}
  721.  
  722. FUNCTION CallColorSearchProc(VAR rgb: RGBColor; VAR position: LONGINT; userRoutine: ColorSearchUPP): BOOLEAN;
  723.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  724.     INLINE $205F, $4E90;
  725.     {$ENDC}
  726.  
  727. FUNCTION CallColorComplementProc(VAR rgb: RGBColor; userRoutine: ColorComplementUPP): BOOLEAN;
  728.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  729.     INLINE $205F, $4E90;
  730.     {$ENDC}
  731.  
  732. TYPE
  733.     ColorSpecPtr = ^ColorSpec;
  734.     ColorSpec = RECORD
  735.         value:                    INTEGER;                                { index or other value }
  736.         rgb:                    RGBColor;                                { true color }
  737.     END;
  738.  
  739.     CSpecArray                            = ARRAY [0..0] OF ColorSpec;
  740.     ColorTablePtr = ^ColorTable;
  741.     ColorTable = RECORD
  742.         ctSeed:                    LONGINT;                                { unique identifier for table }
  743.         ctFlags:                INTEGER;                                { high bit: 0 = PixMap; 1 = device }
  744.         ctSize:                    INTEGER;                                { number of entries in CTTable }
  745.         ctTable:                CSpecArray;                                { array [0..0] of ColorSpec }
  746.     END;
  747.  
  748.     CTabPtr                                = ^ColorTable;
  749.     CTabHandle                            = ^CTabPtr;
  750.     xColorSpecPtr = ^xColorSpec;
  751.     xColorSpec = RECORD
  752.         value:                    INTEGER;                                { index or other value }
  753.         rgb:                    RGBColor;                                { true color }
  754.         xalpha:                    INTEGER;
  755.     END;
  756.  
  757.     xCSpecArray                            = ARRAY [0..0] OF xColorSpec;
  758.     MatchRecPtr = ^MatchRec;
  759.     MatchRec = RECORD
  760.         red:                    UInt16;
  761.         green:                    UInt16;
  762.         blue:                    UInt16;
  763.         matchData:                LONGINT;
  764.     END;
  765.  
  766. {
  767.     QuickTime 3.0 makes PixMap data structure available on non-Mac OS's.
  768.     In order to implement PixMap in these alternate environments, the PixMap
  769.     had to be extended. The pmReserved field was changed to pmExt which is
  770.     a Handle to extra info.  The planeBytes field was changed to pixelFormat.
  771. }
  772. {$IFC UNDEFINED OLDPIXMAPSTRUCT }
  773. {$IFC TARGET_OS_MAC }
  774. {$SETC OLDPIXMAPSTRUCT := 1 }
  775. {$ELSEC}
  776. {$SETC OLDPIXMAPSTRUCT := 0 }
  777. {$ENDC}
  778. {$ENDC}
  779.  
  780. {  pixel formats }
  781.  
  782. CONST
  783.     k1MonochromePixelFormat        = $00000001;                    {  1 bit indexed }
  784.     k2IndexedPixelFormat        = $00000002;                    {  2 bit indexed }
  785.     k4IndexedPixelFormat        = $00000004;                    {  4 bit indexed }
  786.     k8IndexedPixelFormat        = $00000008;                    {  8 bit indexed }
  787.     k16BE555PixelFormat            = $00000010;                    {  16 bit BE rgb 555 (Mac) }
  788.     k24RGBPixelFormat            = $00000018;                    {  24 bit rgb  }
  789.     k32ARGBPixelFormat            = $00000020;                    {  32 bit argb    (Mac) }
  790.     k1IndexedGrayPixelFormat    = $00000021;                    {  1 bit indexed gray }
  791.     k2IndexedGrayPixelFormat    = $00000022;                    {  2 bit indexed gray }
  792.     k4IndexedGrayPixelFormat    = $00000024;                    {  4 bit indexed gray }
  793.     k8IndexedGrayPixelFormat    = $00000028;                    {  8 bit indexed gray }
  794.  
  795.  
  796. {  values for PixMap.pixelFormat }
  797.     k16LE555PixelFormat            = 'L555';                        {  16 bit LE rgb 555 (PC) }
  798.     k16BE565PixelFormat            = 'B565';                        {  16 bit BE rgb 565 }
  799.     k16LE565PixelFormat            = 'L565';                        {  16 bit LE rgb 565 }
  800.     k24BGRPixelFormat            = '24BG';                        {  24 bit bgr  }
  801.     k32BGRAPixelFormat            = 'BGRA';                        {  32 bit bgra    (Matrox) }
  802.     k32ABGRPixelFormat            = 'ABGR';                        {  32 bit abgr     }
  803.     k32RGBAPixelFormat            = 'RGBA';                        {  32 bit rgba     }
  804.     kYUVSPixelFormat            = 'yuvs';                        {  YUV 4:2:2 byte ordering 16-unsigned = 'YUY2' }
  805.     kYUVUPixelFormat            = 'yuvu';                        {  YUV 4:2:2 byte ordering 16-signed }
  806.     kYVU9PixelFormat            = 'YVU9';                        {  YVU9 Planar    9 }
  807.     kYUV411PixelFormat            = 'Y411';                        {  YUV 4:1:1 Interleaved    16 }
  808.     kYVYU422PixelFormat            = 'YVYU';                        {  YVYU 4:2:2 byte ordering    16 }
  809.     kUYVY422PixelFormat            = 'UYVY';                        {  UYVY 4:2:2 byte ordering    16 }
  810.     kYUV211PixelFormat            = 'Y211';                        {  YUV 2:1:1 Packed    8 }
  811.  
  812.  
  813. {$IFC NOT OLDPIXMAPSTRUCT }
  814.  
  815. TYPE
  816.     PixMapExtensionPtr = ^PixMapExtension;
  817.     PixMapExtension = RECORD
  818.         extSize:                LONGINT;                                { size of struct, duh! }
  819.         pmBits:                    UInt32;                                    { pixmap attributes bitfield }
  820.         pmGD:                    Ptr;                                    { this is a GDHandle }
  821.         pmSeed:                    LONGINT;
  822.         reserved0:                UInt32;                                    { reserved for future use }
  823.         reserved1:                UInt32;
  824.         reserved2:                UInt32;
  825.         longRowBytes:            LONGINT;                                { used when rowBytes > 16382 }
  826.     END;
  827.  
  828.     PixMapExtPtr                        = ^PixMapExtension;
  829.     PixMapExtHandle                        = ^PixMapExtPtr;
  830. {$ENDC}
  831.  
  832.  
  833. TYPE
  834.     PixMapPtr = ^PixMap;
  835.     PixMap = RECORD
  836.         baseAddr:                Ptr;                                    { pointer to pixels }
  837.         rowBytes:                INTEGER;                                { offset to next line }
  838.         bounds:                    Rect;                                    { encloses bitmap }
  839.         pmVersion:                INTEGER;                                { pixMap version number }
  840.         packType:                INTEGER;                                { defines packing format }
  841.         packSize:                LONGINT;                                { length of pixel data }
  842.         hRes:                    Fixed;                                    { horiz. resolution (ppi) }
  843.         vRes:                    Fixed;                                    { vert. resolution (ppi) }
  844.         pixelType:                INTEGER;                                { defines pixel type }
  845.         pixelSize:                INTEGER;                                { # bits in pixel }
  846.         cmpCount:                INTEGER;                                { # components in pixel }
  847.         cmpSize:                INTEGER;                                { # bits per component }
  848.         planeBytes:                LONGINT;                                { offset to next plane }
  849.         pmTable:                CTabHandle;                                { color map for this pixMap }
  850.         pmReserved:                LONGINT;
  851.     END;
  852.  
  853.     PixMapHandle                        = ^PixMapPtr;
  854.     PixPatPtr = ^PixPat;
  855.     PixPat = RECORD
  856.         patType:                INTEGER;                                { type of pattern }
  857.         patMap:                    PixMapHandle;                            { the pattern's pixMap }
  858.         patData:                Handle;                                    { pixmap's data }
  859.         patXData:                Handle;                                    { expanded Pattern data }
  860.         patXValid:                INTEGER;                                { flags whether expanded Pattern valid }
  861.         patXMap:                Handle;                                    { Handle to expanded Pattern data }
  862.         pat1Data:                Pattern;                                { old-Style pattern/RGB color }
  863.     END;
  864.  
  865.     PixPatHandle                        = ^PixPatPtr;
  866.     CCrsrPtr = ^CCrsr;
  867.     CCrsr = RECORD
  868.         crsrType:                INTEGER;                                { type of cursor }
  869.         crsrMap:                PixMapHandle;                            { the cursor's pixmap }
  870.         crsrData:                Handle;                                    { cursor's data }
  871.         crsrXData:                Handle;                                    { expanded cursor data }
  872.         crsrXValid:                INTEGER;                                { depth of expanded data (0 if none) }
  873.         crsrXHandle:            Handle;                                    { future use }
  874.         crsr1Data:                Bits16;                                    { one-bit cursor }
  875.         crsrMask:                Bits16;                                    { cursor's mask }
  876.         crsrHotSpot:            Point;                                    { cursor's hotspot }
  877.         crsrXTable:                LONGINT;                                { private }
  878.         crsrID:                    LONGINT;                                { private }
  879.     END;
  880.  
  881.     CCrsrHandle                            = ^CCrsrPtr;
  882. {$IFC OLDROUTINELOCATIONS }
  883.     CIconPtr = ^CIcon;
  884.     CIcon = RECORD
  885.         iconPMap:                PixMap;                                    { the icon's pixMap }
  886.         iconMask:                BitMap;                                    { the icon's mask }
  887.         iconBMap:                BitMap;                                    { the icon's bitMap }
  888.         iconData:                Handle;                                    { the icon's data }
  889.         iconMaskData:            ARRAY [0..0] OF INTEGER;                { icon's mask and BitMap data }
  890.     END;
  891.  
  892.     CIconHandle                            = ^CIconPtr;
  893. {$ENDC}  {OLDROUTINELOCATIONS}
  894.  
  895.     GammaTblPtr = ^GammaTbl;
  896.     GammaTbl = RECORD
  897.         gVersion:                INTEGER;                                { gamma version number }
  898.         gType:                    INTEGER;                                { gamma data type }
  899.         gFormulaSize:            INTEGER;                                { Formula data size }
  900.         gChanCnt:                INTEGER;                                { number of channels of data }
  901.         gDataCnt:                INTEGER;                                { number of values/channel }
  902.         gDataWidth:                INTEGER;                                { bits/corrected value (data packed to next larger byte size) }
  903.         gFormulaData:            ARRAY [0..0] OF INTEGER;                { data for formulas followed by gamma values }
  904.     END;
  905.  
  906.     GammaTblHandle                        = ^GammaTblPtr;
  907.     ITabPtr = ^ITab;
  908.     ITab = RECORD
  909.         iTabSeed:                LONGINT;                                { copy of CTSeed from source CTable }
  910.         iTabRes:                INTEGER;                                { bits/channel resolution of iTable }
  911.         iTTable:                SInt8;                                    { byte colortable index values }
  912.     END;
  913.  
  914.     ITabHandle                            = ^ITabPtr;
  915.     SProcRecPtr = ^SProcRec;
  916.     SProcRec = RECORD
  917.         nxtSrch:                Handle;                                    { SProcHndl Handle to next SProcRec }
  918.         srchProc:                ColorSearchUPP;                            { search procedure proc ptr }
  919.     END;
  920.  
  921.     SProcPtr                            = ^SProcRec;
  922.     SProcHndl                            = ^SProcPtr;
  923.     CProcRecPtr = ^CProcRec;
  924.     CProcRec = RECORD
  925.         nxtComp:                Handle;                                    { CProcHndl Handle to next CProcRec }
  926.         compProc:                ColorComplementUPP;                        { complement procedure proc ptr }
  927.     END;
  928.  
  929.     CProcPtr                            = ^CProcRec;
  930.     CProcHndl                            = ^CProcPtr;
  931. {
  932.     QuickTime 3.0 makes GDevice data structure available on non-Mac OS's.
  933.     In order to implement GDevice in these alternate environments, the GDevice
  934.     had to be extended. The gdReserved field was changed to gdExt which is
  935.     a Handle to extra info.  
  936. }
  937. {$IFC UNDEFINED OLDGDEVICESTRUCT }
  938. {$IFC TARGET_OS_MAC }
  939. {$SETC OLDGDEVICESTRUCT := 1 }
  940. {$ELSEC}
  941. {$SETC OLDGDEVICESTRUCT := 0 }
  942. {$ENDC}
  943. {$ENDC}
  944.  
  945.     GDevicePtr = ^GDevice;
  946.     GDPtr                                = ^GDevice;
  947.     GDHandle                            = ^GDPtr;
  948.     GDevice = RECORD
  949.         gdRefNum:                INTEGER;                                { driver's unit number }
  950.         gdID:                    INTEGER;                                { client ID for search procs }
  951.         gdType:                    INTEGER;                                { fixed/CLUT/direct }
  952.         gdITable:                ITabHandle;                                { Handle to inverse lookup table }
  953.         gdResPref:                INTEGER;                                { preferred resolution of GDITable }
  954.         gdSearchProc:            SProcHndl;                                { search proc list head }
  955.         gdCompProc:                CProcHndl;                                { complement proc list }
  956.         gdFlags:                INTEGER;                                { grafDevice flags word }
  957.         gdPMap:                    PixMapHandle;                            { describing pixMap }
  958.         gdRefCon:                LONGINT;                                { reference value }
  959.         gdNextGD:                GDHandle;                                { GDHandle Handle of next gDevice }
  960.         gdRect:                    Rect;                                    {  device's bounds in global coordinates }
  961.         gdMode:                    LONGINT;                                { device's current mode }
  962.         gdCCBytes:                INTEGER;                                { depth of expanded cursor data }
  963.         gdCCDepth:                INTEGER;                                { depth of expanded cursor data }
  964.         gdCCXData:                Handle;                                    { Handle to cursor's expanded data }
  965.         gdCCXMask:                Handle;                                    { Handle to cursor's expanded mask }
  966.         gdReserved:                LONGINT;                                { future use. MUST BE 0 }
  967.     END;
  968.  
  969.     GrafVars = RECORD
  970.         rgbOpColor:                RGBColor;                                { color for addPin  subPin and average }
  971.         rgbHiliteColor:            RGBColor;                                { color for hiliting }
  972.         pmFgColor:                Handle;                                    { palette Handle for foreground color }
  973.         pmFgIndex:                INTEGER;                                { index value for foreground }
  974.         pmBkColor:                Handle;                                    { palette Handle for background color }
  975.         pmBkIndex:                INTEGER;                                { index value for background }
  976.         pmFlags:                INTEGER;                                { flags for Palette Manager }
  977.     END;
  978.     GVarPtr                                = ^GrafVars;
  979.     GVarHandle                            = ^GVarPtr;
  980.  
  981.     CGrafPortPtr = ^CGrafPort;
  982.     CGrafPtr                            = ^CGrafPort;
  983. {$IFC TYPED_FUNCTION_POINTERS}
  984.     QDPrinterStatusProcPtr = FUNCTION(opcode: PrinterStatusOpcode; currentPort: CGrafPtr; printerStatus: UNIV Ptr): OSStatus; C;
  985. {$ELSEC}
  986.     QDPrinterStatusProcPtr = ProcPtr;
  987. {$ENDC}
  988.  
  989.     QDPrinterStatusUPP = UniversalProcPtr;
  990.  
  991.     CQDProcsPtr = ^CQDProcs;
  992.     CQDProcs = RECORD
  993.         textProc:                QDTextUPP;
  994.         lineProc:                QDLineUPP;
  995.         rectProc:                QDRectUPP;
  996.         rRectProc:                QDRRectUPP;
  997.         ovalProc:                QDOvalUPP;
  998.         arcProc:                QDArcUPP;
  999.         polyProc:                QDPolyUPP;
  1000.         rgnProc:                QDRgnUPP;
  1001.         bitsProc:                QDBitsUPP;
  1002.         commentProc:            QDCommentUPP;
  1003.         txMeasProc:                QDTxMeasUPP;
  1004.         getPicProc:                QDGetPicUPP;
  1005.         putPicProc:                QDPutPicUPP;
  1006.         opcodeProc:                QDOpcodeUPP;
  1007.         newProc1:                UniversalProcPtr;                        {  this is the StdPix bottleneck -- see ImageCompression.h  }
  1008.         glyphsProc:                QDStdGlyphsUPP;                            {  was newProc2; now used in Unicode text drawing  }
  1009.         printerStatusProc:        QDPrinterStatusUPP;                        {  was newProc3;  now used to communicate status between Printing code and System imaging code  }
  1010.         newProc4:                UniversalProcPtr;
  1011.         newProc5:                UniversalProcPtr;
  1012.         newProc6:                UniversalProcPtr;
  1013.     END;
  1014.  
  1015.     CGrafPort = RECORD
  1016.         device:                    INTEGER;
  1017.         portPixMap:                PixMapHandle;                            { port's pixel map }
  1018.         portVersion:            INTEGER;                                { high 2 bits always set }
  1019.         grafVars:                Handle;                                    { Handle to more fields }
  1020.         chExtra:                INTEGER;                                { character extra }
  1021.         pnLocHFrac:                INTEGER;                                { pen fraction }
  1022.         portRect:                Rect;
  1023.         visRgn:                    RgnHandle;
  1024.         clipRgn:                RgnHandle;
  1025.         bkPixPat:                PixPatHandle;                            { background pattern }
  1026.         rgbFgColor:                RGBColor;                                { RGB components of fg }
  1027.         rgbBkColor:                RGBColor;                                { RGB components of bk }
  1028.         pnLoc:                    Point;
  1029.         pnSize:                    Point;
  1030.         pnMode:                    INTEGER;
  1031.         pnPixPat:                PixPatHandle;                            { pen's pattern }
  1032.         fillPixPat:                PixPatHandle;                            { fill pattern }
  1033.         pnVis:                    INTEGER;
  1034.         txFont:                    INTEGER;
  1035.         txFace:                    StyleField;                                { StyleField occupies 16-bits, but only first 8-bits are used }
  1036.         txMode:                    INTEGER;
  1037.         txSize:                    INTEGER;
  1038.         spExtra:                Fixed;
  1039.         fgColor:                LONGINT;
  1040.         bkColor:                LONGINT;
  1041.         colrBit:                INTEGER;
  1042.         patStretch:                INTEGER;
  1043.         picSave:                Handle;
  1044.         rgnSave:                Handle;
  1045.         polySave:                Handle;
  1046.         grafProcs:                CQDProcsPtr;
  1047.     END;
  1048.  
  1049.     CWindowPtr                            = CGrafPtr;
  1050.     ReqListRecPtr = ^ReqListRec;
  1051.     ReqListRec = RECORD
  1052.         reqLSize:                INTEGER;                                { request list size }
  1053.         reqLData:                ARRAY [0..0] OF INTEGER;                { request list data }
  1054.     END;
  1055.  
  1056.     OpenCPicParamsPtr = ^OpenCPicParams;
  1057.     OpenCPicParams = RECORD
  1058.         srcRect:                Rect;
  1059.         hRes:                    Fixed;
  1060.         vRes:                    Fixed;
  1061.         version:                INTEGER;
  1062.         reserved1:                INTEGER;
  1063.         reserved2:                LONGINT;
  1064.     END;
  1065.  
  1066.  
  1067. CONST
  1068.     kCursorImageMajorVersion    = $0001;
  1069.     kCursorImageMinorVersion    = $0000;
  1070.  
  1071.  
  1072. TYPE
  1073.     CursorImageRecPtr = ^CursorImageRec;
  1074.     CursorImageRec = RECORD
  1075.         majorVersion:            UInt16;
  1076.         minorVersion:            UInt16;
  1077.         cursorPixMap:            PixMapHandle;
  1078.         cursorBitMask:            BitMapHandle;
  1079.     END;
  1080.  
  1081.     CursorImagePtr                        = ^CursorImageRec;
  1082. {$IFC TYPED_FUNCTION_POINTERS}
  1083.     DeviceLoopDrawingProcPtr = PROCEDURE(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT);
  1084. {$ELSEC}
  1085.     DeviceLoopDrawingProcPtr = ProcPtr;
  1086. {$ENDC}
  1087.  
  1088.     DeviceLoopDrawingUPP = UniversalProcPtr;
  1089.  
  1090. CONST
  1091.     uppDeviceLoopDrawingProcInfo = $00003E80;
  1092.  
  1093. FUNCTION NewDeviceLoopDrawingProc(userRoutine: DeviceLoopDrawingProcPtr): DeviceLoopDrawingUPP;
  1094.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1095.     INLINE $2E9F;
  1096.     {$ENDC}
  1097.  
  1098. PROCEDURE CallDeviceLoopDrawingProc(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT; userRoutine: DeviceLoopDrawingUPP);
  1099.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1100.     INLINE $205F, $4E90;
  1101.     {$ENDC}
  1102.  
  1103. TYPE
  1104.     QDGlobalsPtr = ^QDGlobals;
  1105.     QDGlobals = RECORD
  1106.         privates:                PACKED ARRAY [0..75] OF CHAR;
  1107.         randSeed:                LONGINT;
  1108.         screenBits:                BitMap;
  1109.         arrow:                    Cursor;
  1110.         dkGray:                    Pattern;
  1111.         ltGray:                    Pattern;
  1112.         gray:                    Pattern;
  1113.         black:                    Pattern;
  1114.         white:                    Pattern;
  1115.         thePort:                GrafPtr;
  1116.     END;
  1117.  
  1118.     QDGlobalsHdl                        = ^QDGlobalsPtr;
  1119.  
  1120. { To be in sync with the C interface to QuickDraw globals, pascal code must now }
  1121. { qualify the QuickDraw globals with “qd.” (e.g. InitGraf(@qd.thePort);  )       }
  1122. VAR
  1123.     {$PUSH}
  1124.     {$J+}
  1125.     qd: QDGlobals;
  1126.     {$POP}
  1127.  
  1128.  
  1129. PROCEDURE InitGraf(globalPtr: UNIV Ptr);
  1130.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1131.     INLINE $A86E;
  1132.     {$ENDC}
  1133. PROCEDURE OpenPort(port: GrafPtr);
  1134.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1135.     INLINE $A86F;
  1136.     {$ENDC}
  1137. PROCEDURE InitPort(port: GrafPtr);
  1138.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1139.     INLINE $A86D;
  1140.     {$ENDC}
  1141. PROCEDURE ClosePort(port: GrafPtr);
  1142.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1143.     INLINE $A87D;
  1144.     {$ENDC}
  1145. {$IFC NOT TARGET_OS_MAC }
  1146. FUNCTION LockPortBits(port: GrafPtr): OSErr;
  1147. FUNCTION UnlockPortBits(port: GrafPtr): OSErr;
  1148. FUNCTION UpdatePort(port: GrafPtr): OSErr;
  1149. FUNCTION GetPortNativeWindow(macPort: GrafPtr): Ptr;
  1150. FUNCTION GetNativeWindowPort(nativeWindow: UNIV Ptr): GrafPtr;
  1151. FUNCTION MacRegionToNativeRegion(macRegion: RgnHandle): Ptr;
  1152. FUNCTION NativeRegionToMacRegion(nativeRegion: UNIV Ptr): RgnHandle;
  1153. {$IFC TARGET_OS_WIN32 }
  1154. FUNCTION GetPortHWND(port: GrafPtr): Ptr;
  1155. FUNCTION GetHWNDPort(theHWND: UNIV Ptr): GrafPtr;
  1156. FUNCTION GetPortHDC(port: GrafPtr): Ptr;
  1157. FUNCTION GetPortHBITMAP(port: GrafPtr): Ptr;
  1158. FUNCTION GetPortHPALETTE(port: GrafPtr): Ptr;
  1159. FUNCTION GetPortHFONT(port: GrafPtr): Ptr;
  1160. FUNCTION GetDIBFromPICT(hPict: PicHandle): Ptr;
  1161. FUNCTION GetPICTFromDIB(h: UNIV Ptr): PicHandle;
  1162. {$ENDC}
  1163. {$ENDC}
  1164.  
  1165.  
  1166. PROCEDURE SetPort(port: GrafPtr);
  1167.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1168.     INLINE $A873;
  1169.     {$ENDC}
  1170. PROCEDURE GetPort(VAR port: GrafPtr);
  1171.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1172.     INLINE $A874;
  1173.     {$ENDC}
  1174. PROCEDURE GrafDevice(device: INTEGER);
  1175.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1176.     INLINE $A872;
  1177.     {$ENDC}
  1178. PROCEDURE SetPortBits({CONST}VAR bm: BitMap);
  1179.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1180.     INLINE $A875;
  1181.     {$ENDC}
  1182. PROCEDURE PortSize(width: INTEGER; height: INTEGER);
  1183.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1184.     INLINE $A876;
  1185.     {$ENDC}
  1186. PROCEDURE MovePortTo(leftGlobal: INTEGER; topGlobal: INTEGER);
  1187.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1188.     INLINE $A877;
  1189.     {$ENDC}
  1190. PROCEDURE SetOrigin(h: INTEGER; v: INTEGER);
  1191.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1192.     INLINE $A878;
  1193.     {$ENDC}
  1194. PROCEDURE SetClip(rgn: RgnHandle);
  1195.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1196.     INLINE $A879;
  1197.     {$ENDC}
  1198. PROCEDURE GetClip(rgn: RgnHandle);
  1199.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1200.     INLINE $A87A;
  1201.     {$ENDC}
  1202. PROCEDURE ClipRect({CONST}VAR r: Rect);
  1203.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1204.     INLINE $A87B;
  1205.     {$ENDC}
  1206. PROCEDURE BackPat({CONST}VAR pat: Pattern);
  1207.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1208.     INLINE $A87C;
  1209.     {$ENDC}
  1210. PROCEDURE InitCursor;
  1211.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1212.     INLINE $A850;
  1213.     {$ENDC}
  1214. PROCEDURE SetCursor({CONST}VAR crsr: Cursor);
  1215.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1216.     INLINE $A851;
  1217.     {$ENDC}
  1218. PROCEDURE HideCursor;
  1219.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1220.     INLINE $A852;
  1221.     {$ENDC}
  1222. PROCEDURE ShowCursor;
  1223.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1224.     INLINE $A853;
  1225.     {$ENDC}
  1226. PROCEDURE ObscureCursor;
  1227.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1228.     INLINE $A856;
  1229.     {$ENDC}
  1230. PROCEDURE HidePen;
  1231.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1232.     INLINE $A896;
  1233.     {$ENDC}
  1234. PROCEDURE ShowPen;
  1235.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1236.     INLINE $A897;
  1237.     {$ENDC}
  1238. PROCEDURE GetPen(VAR pt: Point);
  1239.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1240.     INLINE $A89A;
  1241.     {$ENDC}
  1242. PROCEDURE GetPenState(VAR pnState: PenState);
  1243.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1244.     INLINE $A898;
  1245.     {$ENDC}
  1246. PROCEDURE SetPenState({CONST}VAR pnState: PenState);
  1247.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1248.     INLINE $A899;
  1249.     {$ENDC}
  1250. PROCEDURE PenSize(width: INTEGER; height: INTEGER);
  1251.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1252.     INLINE $A89B;
  1253.     {$ENDC}
  1254. PROCEDURE PenMode(mode: INTEGER);
  1255.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1256.     INLINE $A89C;
  1257.     {$ENDC}
  1258. PROCEDURE PenPat({CONST}VAR pat: Pattern);
  1259.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1260.     INLINE $A89D;
  1261.     {$ENDC}
  1262. PROCEDURE PenNormal;
  1263.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1264.     INLINE $A89E;
  1265.     {$ENDC}
  1266. PROCEDURE MoveTo(h: INTEGER; v: INTEGER);
  1267.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1268.     INLINE $A893;
  1269.     {$ENDC}
  1270. PROCEDURE Move(dh: INTEGER; dv: INTEGER);
  1271.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1272.     INLINE $A894;
  1273.     {$ENDC}
  1274. PROCEDURE LineTo(h: INTEGER; v: INTEGER);
  1275.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1276.     INLINE $A891;
  1277.     {$ENDC}
  1278. PROCEDURE Line(dh: INTEGER; dv: INTEGER);
  1279.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1280.     INLINE $A892;
  1281.     {$ENDC}
  1282. PROCEDURE ForeColor(color: LONGINT);
  1283.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1284.     INLINE $A862;
  1285.     {$ENDC}
  1286. PROCEDURE BackColor(color: LONGINT);
  1287.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1288.     INLINE $A863;
  1289.     {$ENDC}
  1290. PROCEDURE ColorBit(whichBit: INTEGER);
  1291.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1292.     INLINE $A864;
  1293.     {$ENDC}
  1294. PROCEDURE SetRect(VAR r: Rect; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1295.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1296.     INLINE $A8A7;
  1297.     {$ENDC}
  1298. PROCEDURE OffsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1299.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1300.     INLINE $A8A8;
  1301.     {$ENDC}
  1302. PROCEDURE InsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1303.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1304.     INLINE $A8A9;
  1305.     {$ENDC}
  1306. FUNCTION SectRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect): BOOLEAN;
  1307.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1308.     INLINE $A8AA;
  1309.     {$ENDC}
  1310. PROCEDURE UnionRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect);
  1311.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1312.     INLINE $A8AB;
  1313.     {$ENDC}
  1314. FUNCTION EqualRect({CONST}VAR rect1: Rect; {CONST}VAR rect2: Rect): BOOLEAN;
  1315.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1316.     INLINE $A8A6;
  1317.     {$ENDC}
  1318. FUNCTION EmptyRect({CONST}VAR r: Rect): BOOLEAN;
  1319.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1320.     INLINE $A8AE;
  1321.     {$ENDC}
  1322. PROCEDURE FrameRect({CONST}VAR r: Rect);
  1323.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1324.     INLINE $A8A1;
  1325.     {$ENDC}
  1326. PROCEDURE PaintRect({CONST}VAR r: Rect);
  1327.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1328.     INLINE $A8A2;
  1329.     {$ENDC}
  1330. PROCEDURE EraseRect({CONST}VAR r: Rect);
  1331.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1332.     INLINE $A8A3;
  1333.     {$ENDC}
  1334. PROCEDURE InvertRect({CONST}VAR r: Rect);
  1335.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1336.     INLINE $A8A4;
  1337.     {$ENDC}
  1338. PROCEDURE FillRect({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1339.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1340.     INLINE $A8A5;
  1341.     {$ENDC}
  1342. PROCEDURE FrameOval({CONST}VAR r: Rect);
  1343.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1344.     INLINE $A8B7;
  1345.     {$ENDC}
  1346. PROCEDURE PaintOval({CONST}VAR r: Rect);
  1347.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1348.     INLINE $A8B8;
  1349.     {$ENDC}
  1350. PROCEDURE EraseOval({CONST}VAR r: Rect);
  1351.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1352.     INLINE $A8B9;
  1353.     {$ENDC}
  1354. PROCEDURE InvertOval({CONST}VAR r: Rect);
  1355.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1356.     INLINE $A8BA;
  1357.     {$ENDC}
  1358. PROCEDURE FillOval({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1359.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1360.     INLINE $A8BB;
  1361.     {$ENDC}
  1362. PROCEDURE FrameRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1363.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1364.     INLINE $A8B0;
  1365.     {$ENDC}
  1366. PROCEDURE PaintRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1367.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1368.     INLINE $A8B1;
  1369.     {$ENDC}
  1370. PROCEDURE EraseRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1371.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1372.     INLINE $A8B2;
  1373.     {$ENDC}
  1374. PROCEDURE InvertRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1375.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1376.     INLINE $A8B3;
  1377.     {$ENDC}
  1378. PROCEDURE FillRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; {CONST}VAR pat: Pattern);
  1379.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1380.     INLINE $A8B4;
  1381.     {$ENDC}
  1382. PROCEDURE FrameArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1383.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1384.     INLINE $A8BE;
  1385.     {$ENDC}
  1386. PROCEDURE PaintArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1387.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1388.     INLINE $A8BF;
  1389.     {$ENDC}
  1390. PROCEDURE EraseArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1391.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1392.     INLINE $A8C0;
  1393.     {$ENDC}
  1394. PROCEDURE InvertArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1395.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1396.     INLINE $A8C1;
  1397.     {$ENDC}
  1398. PROCEDURE FillArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; {CONST}VAR pat: Pattern);
  1399.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1400.     INLINE $A8C2;
  1401.     {$ENDC}
  1402. FUNCTION NewRgn: RgnHandle;
  1403.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1404.     INLINE $A8D8;
  1405.     {$ENDC}
  1406. PROCEDURE OpenRgn;
  1407.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1408.     INLINE $A8DA;
  1409.     {$ENDC}
  1410. PROCEDURE CloseRgn(dstRgn: RgnHandle);
  1411.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1412.     INLINE $A8DB;
  1413.     {$ENDC}
  1414. FUNCTION BitMapToRegion(region: RgnHandle; {CONST}VAR bMap: BitMap): OSErr;
  1415.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1416.     INLINE $A8D7;
  1417.     {$ENDC}
  1418. PROCEDURE DisposeRgn(rgn: RgnHandle);
  1419.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1420.     INLINE $A8D9;
  1421.     {$ENDC}
  1422. PROCEDURE CopyRgn(srcRgn: RgnHandle; dstRgn: RgnHandle);
  1423.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1424.     INLINE $A8DC;
  1425.     {$ENDC}
  1426. PROCEDURE SetEmptyRgn(rgn: RgnHandle);
  1427.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1428.     INLINE $A8DD;
  1429.     {$ENDC}
  1430. PROCEDURE SetRectRgn(rgn: RgnHandle; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1431.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1432.     INLINE $A8DE;
  1433.     {$ENDC}
  1434. PROCEDURE RectRgn(rgn: RgnHandle; {CONST}VAR r: Rect);
  1435.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1436.     INLINE $A8DF;
  1437.     {$ENDC}
  1438. PROCEDURE OffsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1439.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1440.     INLINE $A8E0;
  1441.     {$ENDC}
  1442. PROCEDURE InsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1443.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1444.     INLINE $A8E1;
  1445.     {$ENDC}
  1446. PROCEDURE SectRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1447.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1448.     INLINE $A8E4;
  1449.     {$ENDC}
  1450. PROCEDURE UnionRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1451.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1452.     INLINE $A8E5;
  1453.     {$ENDC}
  1454. PROCEDURE DiffRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1455.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1456.     INLINE $A8E6;
  1457.     {$ENDC}
  1458. PROCEDURE XorRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1459.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1460.     INLINE $A8E7;
  1461.     {$ENDC}
  1462. FUNCTION RectInRgn({CONST}VAR r: Rect; rgn: RgnHandle): BOOLEAN;
  1463.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1464.     INLINE $A8E9;
  1465.     {$ENDC}
  1466. FUNCTION EqualRgn(rgnA: RgnHandle; rgnB: RgnHandle): BOOLEAN;
  1467.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1468.     INLINE $A8E3;
  1469.     {$ENDC}
  1470. FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
  1471.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1472.     INLINE $A8E2;
  1473.     {$ENDC}
  1474. PROCEDURE FrameRgn(rgn: RgnHandle);
  1475.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1476.     INLINE $A8D2;
  1477.     {$ENDC}
  1478. PROCEDURE PaintRgn(rgn: RgnHandle);
  1479.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1480.     INLINE $A8D3;
  1481.     {$ENDC}
  1482. PROCEDURE EraseRgn(rgn: RgnHandle);
  1483.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1484.     INLINE $A8D4;
  1485.     {$ENDC}
  1486. PROCEDURE InvertRgn(rgn: RgnHandle);
  1487.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1488.     INLINE $A8D5;
  1489.     {$ENDC}
  1490. PROCEDURE FillRgn(rgn: RgnHandle; {CONST}VAR pat: Pattern);
  1491.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1492.     INLINE $A8D6;
  1493.     {$ENDC}
  1494. PROCEDURE ScrollRect({CONST}VAR r: Rect; dh: INTEGER; dv: INTEGER; updateRgn: RgnHandle);
  1495.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1496.     INLINE $A8EF;
  1497.     {$ENDC}
  1498. PROCEDURE CopyBits({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1499.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1500.     INLINE $A8EC;
  1501.     {$ENDC}
  1502. PROCEDURE SeedFill(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER; seedH: INTEGER; seedV: INTEGER);
  1503.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1504.     INLINE $A839;
  1505.     {$ENDC}
  1506. PROCEDURE CalcMask(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER);
  1507.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1508.     INLINE $A838;
  1509.     {$ENDC}
  1510. PROCEDURE CopyMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect);
  1511.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1512.     INLINE $A817;
  1513.     {$ENDC}
  1514. FUNCTION OpenPicture({CONST}VAR picFrame: Rect): PicHandle;
  1515.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1516.     INLINE $A8F3;
  1517.     {$ENDC}
  1518. PROCEDURE PicComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1519.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1520.     INLINE $A8F2;
  1521.     {$ENDC}
  1522. PROCEDURE ClosePicture;
  1523.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1524.     INLINE $A8F4;
  1525.     {$ENDC}
  1526. PROCEDURE DrawPicture(myPicture: PicHandle; {CONST}VAR dstRect: Rect);
  1527.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1528.     INLINE $A8F6;
  1529.     {$ENDC}
  1530. PROCEDURE KillPicture(myPicture: PicHandle);
  1531.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1532.     INLINE $A8F5;
  1533.     {$ENDC}
  1534. FUNCTION OpenPoly: PolyHandle;
  1535.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1536.     INLINE $A8CB;
  1537.     {$ENDC}
  1538. PROCEDURE ClosePoly;
  1539.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1540.     INLINE $A8CC;
  1541.     {$ENDC}
  1542. PROCEDURE KillPoly(poly: PolyHandle);
  1543.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1544.     INLINE $A8CD;
  1545.     {$ENDC}
  1546. PROCEDURE OffsetPoly(poly: PolyHandle; dh: INTEGER; dv: INTEGER);
  1547.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1548.     INLINE $A8CE;
  1549.     {$ENDC}
  1550. PROCEDURE FramePoly(poly: PolyHandle);
  1551.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1552.     INLINE $A8C6;
  1553.     {$ENDC}
  1554. PROCEDURE PaintPoly(poly: PolyHandle);
  1555.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1556.     INLINE $A8C7;
  1557.     {$ENDC}
  1558. PROCEDURE ErasePoly(poly: PolyHandle);
  1559.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1560.     INLINE $A8C8;
  1561.     {$ENDC}
  1562. PROCEDURE InvertPoly(poly: PolyHandle);
  1563.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1564.     INLINE $A8C9;
  1565.     {$ENDC}
  1566. PROCEDURE FillPoly(poly: PolyHandle; {CONST}VAR pat: Pattern);
  1567.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1568.     INLINE $A8CA;
  1569.     {$ENDC}
  1570. PROCEDURE SetPt(VAR pt: Point; h: INTEGER; v: INTEGER);
  1571.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1572.     INLINE $A880;
  1573.     {$ENDC}
  1574. PROCEDURE LocalToGlobal(VAR pt: Point);
  1575.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1576.     INLINE $A870;
  1577.     {$ENDC}
  1578. PROCEDURE GlobalToLocal(VAR pt: Point);
  1579.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1580.     INLINE $A871;
  1581.     {$ENDC}
  1582. FUNCTION Random: INTEGER;
  1583.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1584.     INLINE $A861;
  1585.     {$ENDC}
  1586. PROCEDURE StuffHex(thingPtr: UNIV Ptr; s: Str255);
  1587.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1588.     INLINE $A866;
  1589.     {$ENDC}
  1590. FUNCTION GetPixel(h: INTEGER; v: INTEGER): BOOLEAN;
  1591.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1592.     INLINE $A865;
  1593.     {$ENDC}
  1594. PROCEDURE ScalePt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1595.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1596.     INLINE $A8F8;
  1597.     {$ENDC}
  1598. PROCEDURE MapPt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1599.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1600.     INLINE $A8F9;
  1601.     {$ENDC}
  1602. PROCEDURE MapRect(VAR r: Rect; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1603.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1604.     INLINE $A8FA;
  1605.     {$ENDC}
  1606. PROCEDURE MapRgn(rgn: RgnHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1607.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1608.     INLINE $A8FB;
  1609.     {$ENDC}
  1610. PROCEDURE MapPoly(poly: PolyHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1611.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1612.     INLINE $A8FC;
  1613.     {$ENDC}
  1614. PROCEDURE SetStdProcs(VAR procs: QDProcs);
  1615.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1616.     INLINE $A8EA;
  1617.     {$ENDC}
  1618. PROCEDURE StdRect(verb: GrafVerb; {CONST}VAR r: Rect);
  1619.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1620.     INLINE $A8A0;
  1621.     {$ENDC}
  1622. PROCEDURE StdRRect(verb: GrafVerb; {CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1623.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1624.     INLINE $A8AF;
  1625.     {$ENDC}
  1626. PROCEDURE StdOval(verb: GrafVerb; {CONST}VAR r: Rect);
  1627.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1628.     INLINE $A8B6;
  1629.     {$ENDC}
  1630. PROCEDURE StdArc(verb: GrafVerb; {CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1631.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1632.     INLINE $A8BD;
  1633.     {$ENDC}
  1634. PROCEDURE StdPoly(verb: GrafVerb; poly: PolyHandle);
  1635.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1636.     INLINE $A8C5;
  1637.     {$ENDC}
  1638. PROCEDURE StdRgn(verb: GrafVerb; rgn: RgnHandle);
  1639.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1640.     INLINE $A8D1;
  1641.     {$ENDC}
  1642. PROCEDURE StdBits({CONST}VAR srcBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1643.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1644.     INLINE $A8EB;
  1645.     {$ENDC}
  1646. PROCEDURE StdComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1647.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1648.     INLINE $A8F1;
  1649.     {$ENDC}
  1650. PROCEDURE StdGetPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1651.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1652.     INLINE $A8EE;
  1653.     {$ENDC}
  1654. PROCEDURE StdPutPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1655.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1656.     INLINE $A8F0;
  1657.     {$ENDC}
  1658. PROCEDURE StdOpcode({CONST}VAR fromRect: Rect; {CONST}VAR toRect: Rect; opcode: UInt16; version: SInt16);
  1659.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1660.     INLINE $ABF8;
  1661.     {$ENDC}
  1662. PROCEDURE AddPt(src: Point; VAR dst: Point);
  1663.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1664.     INLINE $A87E;
  1665.     {$ENDC}
  1666. FUNCTION EqualPt(pt1: Point; pt2: Point): BOOLEAN;
  1667.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1668.     INLINE $A881;
  1669.     {$ENDC}
  1670. FUNCTION PtInRect(pt: Point; {CONST}VAR r: Rect): BOOLEAN;
  1671.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1672.     INLINE $A8AD;
  1673.     {$ENDC}
  1674. PROCEDURE Pt2Rect(pt1: Point; pt2: Point; VAR dstRect: Rect);
  1675.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1676.     INLINE $A8AC;
  1677.     {$ENDC}
  1678. PROCEDURE PtToAngle({CONST}VAR r: Rect; pt: Point; VAR angle: INTEGER);
  1679.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1680.     INLINE $A8C3;
  1681.     {$ENDC}
  1682. PROCEDURE SubPt(src: Point; VAR dst: Point);
  1683.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1684.     INLINE $A87F;
  1685.     {$ENDC}
  1686. FUNCTION PtInRgn(pt: Point; rgn: RgnHandle): BOOLEAN;
  1687.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1688.     INLINE $A8E8;
  1689.     {$ENDC}
  1690. PROCEDURE StdLine(newPt: Point);
  1691.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1692.     INLINE $A890;
  1693.     {$ENDC}
  1694. PROCEDURE OpenCPort(port: CGrafPtr);
  1695.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1696.     INLINE $AA00;
  1697.     {$ENDC}
  1698. PROCEDURE InitCPort(port: CGrafPtr);
  1699.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1700.     INLINE $AA01;
  1701.     {$ENDC}
  1702. PROCEDURE CloseCPort(port: CGrafPtr);
  1703.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1704.     INLINE $AA02;
  1705.     {$ENDC}
  1706. FUNCTION NewPixMap: PixMapHandle;
  1707.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1708.     INLINE $AA03;
  1709.     {$ENDC}
  1710. PROCEDURE DisposePixMap(pm: PixMapHandle);
  1711.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1712.     INLINE $AA04;
  1713.     {$ENDC}
  1714. PROCEDURE CopyPixMap(srcPM: PixMapHandle; dstPM: PixMapHandle);
  1715.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1716.     INLINE $AA05;
  1717.     {$ENDC}
  1718. FUNCTION NewPixPat: PixPatHandle;
  1719.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1720.     INLINE $AA07;
  1721.     {$ENDC}
  1722. PROCEDURE DisposePixPat(pp: PixPatHandle);
  1723.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1724.     INLINE $AA08;
  1725.     {$ENDC}
  1726. PROCEDURE CopyPixPat(srcPP: PixPatHandle; dstPP: PixPatHandle);
  1727.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1728.     INLINE $AA09;
  1729.     {$ENDC}
  1730. PROCEDURE PenPixPat(pp: PixPatHandle);
  1731.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1732.     INLINE $AA0A;
  1733.     {$ENDC}
  1734. PROCEDURE BackPixPat(pp: PixPatHandle);
  1735.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1736.     INLINE $AA0B;
  1737.     {$ENDC}
  1738. FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
  1739.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1740.     INLINE $AA0C;
  1741.     {$ENDC}
  1742. PROCEDURE MakeRGBPat(pp: PixPatHandle; {CONST}VAR myColor: RGBColor);
  1743.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1744.     INLINE $AA0D;
  1745.     {$ENDC}
  1746. PROCEDURE FillCRect({CONST}VAR r: Rect; pp: PixPatHandle);
  1747.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1748.     INLINE $AA0E;
  1749.     {$ENDC}
  1750. PROCEDURE FillCOval({CONST}VAR r: Rect; pp: PixPatHandle);
  1751.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1752.     INLINE $AA0F;
  1753.     {$ENDC}
  1754. PROCEDURE FillCRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; pp: PixPatHandle);
  1755.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1756.     INLINE $AA10;
  1757.     {$ENDC}
  1758. PROCEDURE FillCArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; pp: PixPatHandle);
  1759.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1760.     INLINE $AA11;
  1761.     {$ENDC}
  1762. PROCEDURE FillCRgn(rgn: RgnHandle; pp: PixPatHandle);
  1763.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1764.     INLINE $AA12;
  1765.     {$ENDC}
  1766. PROCEDURE FillCPoly(poly: PolyHandle; pp: PixPatHandle);
  1767.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1768.     INLINE $AA13;
  1769.     {$ENDC}
  1770. PROCEDURE RGBForeColor({CONST}VAR color: RGBColor);
  1771.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1772.     INLINE $AA14;
  1773.     {$ENDC}
  1774. PROCEDURE RGBBackColor({CONST}VAR color: RGBColor);
  1775.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1776.     INLINE $AA15;
  1777.     {$ENDC}
  1778. PROCEDURE SetCPixel(h: INTEGER; v: INTEGER; {CONST}VAR cPix: RGBColor);
  1779.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1780.     INLINE $AA16;
  1781.     {$ENDC}
  1782. PROCEDURE SetPortPix(pm: PixMapHandle);
  1783.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1784.     INLINE $AA06;
  1785.     {$ENDC}
  1786. PROCEDURE GetCPixel(h: INTEGER; v: INTEGER; VAR cPix: RGBColor);
  1787.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1788.     INLINE $AA17;
  1789.     {$ENDC}
  1790. PROCEDURE GetForeColor(VAR color: RGBColor);
  1791.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1792.     INLINE $AA19;
  1793.     {$ENDC}
  1794. PROCEDURE GetBackColor(VAR color: RGBColor);
  1795.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1796.     INLINE $AA1A;
  1797.     {$ENDC}
  1798. PROCEDURE SeedCFill({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; seedH: INTEGER; seedV: INTEGER; matchProc: ColorSearchUPP; matchData: LONGINT);
  1799.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1800.     INLINE $AA50;
  1801.     {$ENDC}
  1802. PROCEDURE CalcCMask({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; {CONST}VAR seedRGB: RGBColor; matchProc: ColorSearchUPP; matchData: LONGINT);
  1803.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1804.     INLINE $AA4F;
  1805.     {$ENDC}
  1806. FUNCTION OpenCPicture({CONST}VAR newHeader: OpenCPicParams): PicHandle;
  1807.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1808.     INLINE $AA20;
  1809.     {$ENDC}
  1810. PROCEDURE OpColor({CONST}VAR color: RGBColor);
  1811.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1812.     INLINE $AA21;
  1813.     {$ENDC}
  1814. PROCEDURE HiliteColor({CONST}VAR color: RGBColor);
  1815.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1816.     INLINE $AA22;
  1817.     {$ENDC}
  1818. PROCEDURE DisposeCTable(cTable: CTabHandle);
  1819.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1820.     INLINE $AA24;
  1821.     {$ENDC}
  1822. FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
  1823.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1824.     INLINE $AA18;
  1825.     {$ENDC}
  1826. FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
  1827.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1828.     INLINE $AA1B;
  1829.     {$ENDC}
  1830. PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
  1831.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1832.     INLINE $AA1C;
  1833.     {$ENDC}
  1834. PROCEDURE AllocCursor;
  1835.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1836.     INLINE $AA1D;
  1837.     {$ENDC}
  1838. PROCEDURE DisposeCCursor(cCrsr: CCrsrHandle);
  1839.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1840.     INLINE $AA26;
  1841.     {$ENDC}
  1842. {$IFC OLDROUTINELOCATIONS }
  1843. FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
  1844.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1845.     INLINE $AA1E;
  1846.     {$ENDC}
  1847. PROCEDURE PlotCIcon({CONST}VAR theRect: Rect; theIcon: CIconHandle);
  1848.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1849.     INLINE $AA1F;
  1850.     {$ENDC}
  1851. PROCEDURE DisposeCIcon(theIcon: CIconHandle);
  1852.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1853.     INLINE $AA25;
  1854.     {$ENDC}
  1855. {$ENDC}  {OLDROUTINELOCATIONS}
  1856.  
  1857. PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
  1858.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1859.     INLINE $AA4E;
  1860.     {$ENDC}
  1861. FUNCTION GetMaxDevice({CONST}VAR globalRect: Rect): GDHandle;
  1862.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1863.     INLINE $AA27;
  1864.     {$ENDC}
  1865. FUNCTION GetCTSeed: LONGINT;
  1866.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1867.     INLINE $AA28;
  1868.     {$ENDC}
  1869. FUNCTION GetDeviceList: GDHandle;
  1870.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1871.     INLINE $AA29;
  1872.     {$ENDC}
  1873. FUNCTION GetMainDevice: GDHandle;
  1874.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1875.     INLINE $AA2A;
  1876.     {$ENDC}
  1877. FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
  1878.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1879.     INLINE $AA2B;
  1880.     {$ENDC}
  1881. FUNCTION TestDeviceAttribute(gdh: GDHandle; attribute: INTEGER): BOOLEAN;
  1882.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1883.     INLINE $AA2C;
  1884.     {$ENDC}
  1885. PROCEDURE SetDeviceAttribute(gdh: GDHandle; attribute: INTEGER; value: BOOLEAN);
  1886.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1887.     INLINE $AA2D;
  1888.     {$ENDC}
  1889. PROCEDURE InitGDevice(qdRefNum: INTEGER; mode: LONGINT; gdh: GDHandle);
  1890.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1891.     INLINE $AA2E;
  1892.     {$ENDC}
  1893. FUNCTION NewGDevice(refNum: INTEGER; mode: LONGINT): GDHandle;
  1894.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1895.     INLINE $AA2F;
  1896.     {$ENDC}
  1897. PROCEDURE DisposeGDevice(gdh: GDHandle);
  1898.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1899.     INLINE $AA30;
  1900.     {$ENDC}
  1901. PROCEDURE SetGDevice(gd: GDHandle);
  1902.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1903.     INLINE $AA31;
  1904.     {$ENDC}
  1905. FUNCTION GetGDevice: GDHandle;
  1906.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1907.     INLINE $AA32;
  1908.     {$ENDC}
  1909. FUNCTION Color2Index({CONST}VAR myColor: RGBColor): LONGINT;
  1910.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1911.     INLINE $AA33;
  1912.     {$ENDC}
  1913. PROCEDURE Index2Color(index: LONGINT; VAR aColor: RGBColor);
  1914.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1915.     INLINE $AA34;
  1916.     {$ENDC}
  1917. PROCEDURE InvertColor(VAR myColor: RGBColor);
  1918.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1919.     INLINE $AA35;
  1920.     {$ENDC}
  1921. FUNCTION RealColor({CONST}VAR color: RGBColor): BOOLEAN;
  1922.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1923.     INLINE $AA36;
  1924.     {$ENDC}
  1925. PROCEDURE GetSubTable(myColors: CTabHandle; iTabRes: INTEGER; targetTbl: CTabHandle);
  1926.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1927.     INLINE $AA37;
  1928.     {$ENDC}
  1929. PROCEDURE MakeITable(cTabH: CTabHandle; iTabH: ITabHandle; res: INTEGER);
  1930.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1931.     INLINE $AA39;
  1932.     {$ENDC}
  1933. PROCEDURE AddSearch(searchProc: ColorSearchUPP);
  1934.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1935.     INLINE $AA3A;
  1936.     {$ENDC}
  1937. PROCEDURE AddComp(compProc: ColorComplementUPP);
  1938.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1939.     INLINE $AA3B;
  1940.     {$ENDC}
  1941. PROCEDURE DelSearch(searchProc: ColorSearchUPP);
  1942.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1943.     INLINE $AA4C;
  1944.     {$ENDC}
  1945. PROCEDURE DelComp(compProc: ColorComplementUPP);
  1946.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1947.     INLINE $AA4D;
  1948.     {$ENDC}
  1949. PROCEDURE SetClientID(id: INTEGER);
  1950.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1951.     INLINE $AA3C;
  1952.     {$ENDC}
  1953. PROCEDURE ProtectEntry(index: INTEGER; protect: BOOLEAN);
  1954.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1955.     INLINE $AA3D;
  1956.     {$ENDC}
  1957. PROCEDURE ReserveEntry(index: INTEGER; reserve: BOOLEAN);
  1958.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1959.     INLINE $AA3E;
  1960.     {$ENDC}
  1961. PROCEDURE SetEntries(start: INTEGER; count: INTEGER; VAR aTable: CSpecArray);
  1962.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1963.     INLINE $AA3F;
  1964.     {$ENDC}
  1965. PROCEDURE SaveEntries(srcTable: CTabHandle; resultTable: CTabHandle; VAR selection: ReqListRec);
  1966.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1967.     INLINE $AA49;
  1968.     {$ENDC}
  1969. PROCEDURE RestoreEntries(srcTable: CTabHandle; dstTable: CTabHandle; VAR selection: ReqListRec);
  1970.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1971.     INLINE $AA4A;
  1972.     {$ENDC}
  1973. FUNCTION QDError: INTEGER;
  1974.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1975.     INLINE $AA40;
  1976.     {$ENDC}
  1977. PROCEDURE CopyDeepMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1978.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1979.     INLINE $AA51;
  1980.     {$ENDC}
  1981. PROCEDURE DeviceLoop(drawingRgn: RgnHandle; drawingProc: DeviceLoopDrawingUPP; userData: LONGINT; flags: DeviceLoopFlags);
  1982.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1983.     INLINE $ABCA;
  1984.     {$ENDC}
  1985.  
  1986. FUNCTION GetMaskTable: Ptr;
  1987.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1988.     INLINE $A836, $2E88;
  1989.     {$ENDC}
  1990. FUNCTION GetPattern(patternID: INTEGER): PatHandle;
  1991.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1992.     INLINE $A9B8;
  1993.     {$ENDC}
  1994. FUNCTION GetCursor(cursorID: INTEGER): CursHandle;
  1995.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  1996.     INLINE $A9B9;
  1997.     {$ENDC}
  1998. FUNCTION GetPicture(pictureID: INTEGER): PicHandle;
  1999.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2000.     INLINE $A9BC;
  2001.     {$ENDC}
  2002. FUNCTION DeltaPoint(ptA: Point; ptB: Point): LONGINT;
  2003.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2004.     INLINE $A94F;
  2005.     {$ENDC}
  2006. PROCEDURE ShieldCursor({CONST}VAR shieldRect: Rect; offsetPt: Point);
  2007.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2008.     INLINE $A855;
  2009.     {$ENDC}
  2010. PROCEDURE ScreenRes(VAR scrnHRes: INTEGER; VAR scrnVRes: INTEGER);
  2011.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2012.     INLINE $225F, $32B8, $0102, $225F, $32B8, $0104;
  2013.     {$ENDC}
  2014. PROCEDURE GetIndPattern(VAR thePat: Pattern; patternListID: INTEGER; index: INTEGER);
  2015. {$IFC OLDROUTINENAMES }
  2016. PROCEDURE DisposPixMap(pm: PixMapHandle);
  2017.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2018.     INLINE $AA04;
  2019.     {$ENDC}
  2020. PROCEDURE DisposPixPat(pp: PixPatHandle);
  2021.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2022.     INLINE $AA08;
  2023.     {$ENDC}
  2024. PROCEDURE DisposCTable(cTable: CTabHandle);
  2025.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2026.     INLINE $AA24;
  2027.     {$ENDC}
  2028. PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
  2029.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2030.     INLINE $AA26;
  2031.     {$ENDC}
  2032. {$IFC OLDROUTINELOCATIONS }
  2033. PROCEDURE DisposCIcon(theIcon: CIconHandle);
  2034.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2035.     INLINE $AA25;
  2036.     {$ENDC}
  2037. {$ENDC}
  2038. PROCEDURE DisposGDevice(gdh: GDHandle);
  2039.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2040.     INLINE $AA30;
  2041.     {$ENDC}
  2042. {$IFC OLDROUTINELOCATIONS }
  2043. {$ENDC}
  2044. {$ENDC}  {OLDROUTINENAMES}
  2045.  
  2046. {
  2047.     From ToolUtils.i
  2048. }
  2049. PROCEDURE PackBits(VAR srcPtr: Ptr; VAR dstPtr: Ptr; srcBytes: INTEGER);
  2050.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2051.     INLINE $A8CF;
  2052.     {$ENDC}
  2053. PROCEDURE UnpackBits(VAR srcPtr: Ptr; VAR dstPtr: Ptr; dstBytes: INTEGER);
  2054.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2055.     INLINE $A8D0;
  2056.     {$ENDC}
  2057. FUNCTION SlopeFromAngle(angle: INTEGER): Fixed;
  2058.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2059.     INLINE $A8BC;
  2060.     {$ENDC}
  2061. FUNCTION AngleFromSlope(slope: Fixed): INTEGER;
  2062.     {$IFC TARGET_OS_MAC AND TARGET_CPU_68K AND NOT TARGET_RT_MAC_CFM}
  2063.     INLINE $A8C4;
  2064.     {$ENDC}
  2065.  
  2066.  
  2067.  
  2068.  
  2069.  
  2070.  
  2071.  
  2072.  
  2073.  
  2074.  
  2075.  
  2076. {$ALIGN RESET}
  2077. {$POP}
  2078.  
  2079. {$SETC UsingIncludes := QuickdrawIncludes}
  2080.  
  2081. {$ENDC} {__QUICKDRAW__}
  2082.  
  2083. {$IFC NOT UsingIncludes}
  2084.  END.
  2085. {$ENDC}
  2086.